home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / email / utils.pyc (.txt) < prev   
Python Compiled Bytecode  |  2008-10-29  |  9KB  |  303 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Miscellaneous utilities.'''
  5. __all__ = [
  6.     'collapse_rfc2231_value',
  7.     'decode_params',
  8.     'decode_rfc2231',
  9.     'encode_rfc2231',
  10.     'formataddr',
  11.     'formatdate',
  12.     'getaddresses',
  13.     'make_msgid',
  14.     'parseaddr',
  15.     'parsedate',
  16.     'parsedate_tz',
  17.     'unquote']
  18. import os
  19. import re
  20. import time
  21. import base64
  22. import random
  23. import socket
  24. import urllib
  25. import warnings
  26. from cStringIO import StringIO
  27. from email._parseaddr import quote
  28. from email._parseaddr import AddressList as _AddressList
  29. from email._parseaddr import mktime_tz
  30. from email._parseaddr import parsedate as _parsedate
  31. from email._parseaddr import parsedate_tz as _parsedate_tz
  32. from quopri import decodestring as _qdecode
  33. from email.encoders import _bencode, _qencode
  34. COMMASPACE = ', '
  35. EMPTYSTRING = ''
  36. UEMPTYSTRING = u''
  37. CRLF = '\r\n'
  38. TICK = "'"
  39. specialsre = re.compile('[][\\\\()<>@,:;".]')
  40. escapesre = re.compile('[][\\\\()"]')
  41.  
  42. def _identity(s):
  43.     return s
  44.  
  45.  
  46. def _bdecode(s):
  47.     if not s:
  48.         return s
  49.     
  50.     value = base64.decodestring(s)
  51.     if not s.endswith('\n') and value.endswith('\n'):
  52.         return value[:-1]
  53.     
  54.     return value
  55.  
  56.  
  57. def fix_eols(s):
  58.     '''Replace all line-ending characters with \r
  59. .'''
  60.     s = re.sub('(?<!\\r)\\n', CRLF, s)
  61.     s = re.sub('\\r(?!\\n)', CRLF, s)
  62.     return s
  63.  
  64.  
  65. def formataddr(pair):
  66.     '''The inverse of parseaddr(), this takes a 2-tuple of the form
  67.     (realname, email_address) and returns the string value suitable
  68.     for an RFC 2822 From, To or Cc header.
  69.  
  70.     If the first element of pair is false, then the second element is
  71.     returned unmodified.
  72.     '''
  73.     (name, address) = pair
  74.     if name:
  75.         quotes = ''
  76.         if specialsre.search(name):
  77.             quotes = '"'
  78.         
  79.         name = escapesre.sub('\\\\\\g<0>', name)
  80.         return '%s%s%s <%s>' % (quotes, name, quotes, address)
  81.     
  82.     return address
  83.  
  84.  
  85. def getaddresses(fieldvalues):
  86.     '''Return a list of (REALNAME, EMAIL) for each fieldvalue.'''
  87.     all = COMMASPACE.join(fieldvalues)
  88.     a = _AddressList(all)
  89.     return a.addresslist
  90.  
  91. ecre = re.compile('\n  =\\?                   # literal =?\n  (?P<charset>[^?]*?)   # non-greedy up to the next ? is the charset\n  \\?                    # literal ?\n  (?P<encoding>[qb])    # either a "q" or a "b", case insensitive\n  \\?                    # literal ?\n  (?P<atom>.*?)         # non-greedy up to the next ?= is the atom\n  \\?=                   # literal ?=\n  ', re.VERBOSE | re.IGNORECASE)
  92.  
  93. def formatdate(timeval = None, localtime = False, usegmt = False):
  94.     '''Returns a date string as specified by RFC 2822, e.g.:
  95.  
  96.     Fri, 09 Nov 2001 01:08:47 -0000
  97.  
  98.     Optional timeval if given is a floating point time value as accepted by
  99.     gmtime() and localtime(), otherwise the current time is used.
  100.  
  101.     Optional localtime is a flag that when True, interprets timeval, and
  102.     returns a date relative to the local timezone instead of UTC, properly
  103.     taking daylight savings time into account.
  104.  
  105.     Optional argument usegmt means that the timezone is written out as
  106.     an ascii string, not numeric one (so "GMT" instead of "+0000"). This
  107.     is needed for HTTP, and is only used when localtime==False.
  108.     '''
  109.     if timeval is None:
  110.         timeval = time.time()
  111.     
  112.     if localtime:
  113.         now = time.localtime(timeval)
  114.         if time.daylight and now[-1]:
  115.             offset = time.altzone
  116.         else:
  117.             offset = time.timezone
  118.         (hours, minutes) = divmod(abs(offset), 3600)
  119.         if offset > 0:
  120.             sign = '-'
  121.         else:
  122.             sign = '+'
  123.         zone = '%s%02d%02d' % (sign, hours, minutes // 60)
  124.     else:
  125.         now = time.gmtime(timeval)
  126.         if usegmt:
  127.             zone = 'GMT'
  128.         else:
  129.             zone = '-0000'
  130.     return '%s, %02d %s %04d %02d:%02d:%02d %s' % ([
  131.         'Mon',
  132.         'Tue',
  133.         'Wed',
  134.         'Thu',
  135.         'Fri',
  136.         'Sat',
  137.         'Sun'][now[6]], now[2], [
  138.         'Jan',
  139.         'Feb',
  140.         'Mar',
  141.         'Apr',
  142.         'May',
  143.         'Jun',
  144.         'Jul',
  145.         'Aug',
  146.         'Sep',
  147.         'Oct',
  148.         'Nov',
  149.         'Dec'][now[1] - 1], now[0], now[3], now[4], now[5], zone)
  150.  
  151.  
  152. def make_msgid(idstring = None):
  153.     '''Returns a string suitable for RFC 2822 compliant Message-ID, e.g:
  154.  
  155.     <20020201195627.33539.96671@nightshade.la.mastaler.com>
  156.  
  157.     Optional idstring if given is a string used to strengthen the
  158.     uniqueness of the message id.
  159.     '''
  160.     timeval = time.time()
  161.     utcdate = time.strftime('%Y%m%d%H%M%S', time.gmtime(timeval))
  162.     pid = os.getpid()
  163.     randint = random.randrange(100000)
  164.     if idstring is None:
  165.         idstring = ''
  166.     else:
  167.         idstring = '.' + idstring
  168.     idhost = socket.getfqdn()
  169.     msgid = '<%s.%s.%s%s@%s>' % (utcdate, pid, randint, idstring, idhost)
  170.     return msgid
  171.  
  172.  
  173. def parsedate(data):
  174.     if not data:
  175.         return None
  176.     
  177.     return _parsedate(data)
  178.  
  179.  
  180. def parsedate_tz(data):
  181.     if not data:
  182.         return None
  183.     
  184.     return _parsedate_tz(data)
  185.  
  186.  
  187. def parseaddr(addr):
  188.     addrs = _AddressList(addr).addresslist
  189.     if not addrs:
  190.         return ('', '')
  191.     
  192.     return addrs[0]
  193.  
  194.  
  195. def unquote(str):
  196.     '''Remove quotes from a string.'''
  197.     if len(str) > 1:
  198.         if str.startswith('"') and str.endswith('"'):
  199.             return str[1:-1].replace('\\\\', '\\').replace('\\"', '"')
  200.         
  201.         if str.startswith('<') and str.endswith('>'):
  202.             return str[1:-1]
  203.         
  204.     
  205.     return str
  206.  
  207.  
  208. def decode_rfc2231(s):
  209.     '''Decode string according to RFC 2231'''
  210.     parts = s.split(TICK, 2)
  211.     if len(parts) <= 2:
  212.         return (None, None, s)
  213.     
  214.     return parts
  215.  
  216.  
  217. def encode_rfc2231(s, charset = None, language = None):
  218.     '''Encode string according to RFC 2231.
  219.  
  220.     If neither charset nor language is given, then s is returned as-is.  If
  221.     charset is given but not language, the string is encoded using the empty
  222.     string for language.
  223.     '''
  224.     import urllib as urllib
  225.     s = urllib.quote(s, safe = '')
  226.     if charset is None and language is None:
  227.         return s
  228.     
  229.     if language is None:
  230.         language = ''
  231.     
  232.     return "%s'%s'%s" % (charset, language, s)
  233.  
  234. rfc2231_continuation = re.compile('^(?P<name>\\w+)\\*((?P<num>[0-9]+)\\*?)?$')
  235.  
  236. def decode_params(params):
  237.     '''Decode parameters list according to RFC 2231.
  238.  
  239.     params is a sequence of 2-tuples containing (param name, string value).
  240.     '''
  241.     params = params[:]
  242.     new_params = []
  243.     rfc2231_params = { }
  244.     (name, value) = params.pop(0)
  245.     new_params.append((name, value))
  246.     while params:
  247.         (name, value) = params.pop(0)
  248.         if name.endswith('*'):
  249.             encoded = True
  250.         else:
  251.             encoded = False
  252.         value = unquote(value)
  253.         mo = rfc2231_continuation.match(name)
  254.         if mo:
  255.             (name, num) = mo.group('name', 'num')
  256.             if num is not None:
  257.                 num = int(num)
  258.             
  259.             rfc2231_params.setdefault(name, []).append((num, value, encoded))
  260.             continue
  261.         new_params.append((name, '"%s"' % quote(value)))
  262.     if rfc2231_params:
  263.         for name, continuations in rfc2231_params.items():
  264.             value = []
  265.             extended = False
  266.             continuations.sort()
  267.             for num, s, encoded in continuations:
  268.                 if encoded:
  269.                     s = urllib.unquote(s)
  270.                     extended = True
  271.                 
  272.                 value.append(s)
  273.             
  274.             value = quote(EMPTYSTRING.join(value))
  275.             if extended:
  276.                 (charset, language, value) = decode_rfc2231(value)
  277.                 new_params.append((name, (charset, language, '"%s"' % value)))
  278.                 continue
  279.             new_params.append((name, '"%s"' % value))
  280.         
  281.     
  282.     return new_params
  283.  
  284.  
  285. def collapse_rfc2231_value(value, errors = 'replace', fallback_charset = 'us-ascii'):
  286.     if isinstance(value, tuple):
  287.         rawval = unquote(value[2])
  288.         if not value[0]:
  289.             pass
  290.         charset = 'us-ascii'
  291.         
  292.         try:
  293.             return unicode(rawval, charset, errors)
  294.         except LookupError:
  295.             return unicode(rawval, fallback_charset, errors)
  296.         except:
  297.             None<EXCEPTION MATCH>LookupError
  298.         
  299.  
  300.     None<EXCEPTION MATCH>LookupError
  301.     return unquote(value)
  302.  
  303.